名域 ts {
    导出 类型 错误回调_ = (消息: 诊断信息_, 长度: 数字) => 无值;

    /* @internal */
    导出 函数 令牌是标识符或关键字(令牌: 语法_): 真假 {
        返回 令牌 >= 语法_.标识符_;
    }

    /* @internal */
    导出 函数 令牌是标识符或关键字或右尖号(令牌: 语法_): 真假 {
        返回 令牌 === 语法_.右尖号_ || 令牌是标识符或关键字(令牌);
    }

    导出 接口 扫描器_ {
        获取开始首位(): 数字;
        获取令牌(): 语法_;
        获取文本首位(): 数字;
        获取令牌首位(): 数字;
        获取令牌文本(): 文字;
        获取令牌值(): 文字;
        有扩展万码转义(): 真假;
        具有前导换行符(): 真假;
        是标识符(): 真假;
        是保留关键字(): 真假;
        是未终止的(): 真假;
        /* @internal */
        获取令牌标志(): 令牌标志_;
        预扫描右尖号令牌(): 语法_;
        预扫描斜杠号令牌(): 语法_;
        预扫描模板令牌(): 语法_;
        扫描JSDoc令牌(): JsDoc语法_;
        扫描(): 语法_;
        获取文本(): 文字;
        设置文本(文本: 文字, 开始?: 数字, 长度?: 数字): 无值;
        设置正在错误(正在错误: 错误回调_): 无值;
        设置文本首位(文本首位: 数字): 无值;
        前瞻<T>(cb: () => T): T;
        扫描范围<T>(开始: 数字, 长度: 数字, cb: () => T): T;
        尝试扫描<T>(cb: () => T): T;
    }

    常量 文本令牌 = 创建词典从模板({
        '变量': 语法_.变量_,
        '从': 语法_.从_,
        '程序': 语法_.程序_,
        '常量': 语法_.常量_,
        '创建': 语法_.创建_,
        '导入': 语法_.导入_,
        '返回': 语法_.返回_,
        '否则': 语法_.否则_,
        '方法': 语法_.方法_,
        '范围': 语法_.范围_,
        '启动': 语法_.启动_,
        '初始': 语法_.初始_,
        '贯穿': 语法_.贯穿_,
        '函数': 语法_.函数_,
        '接口': 语法_.接口_,
        '枚举': 语法_.枚举_,
        '假如': 语法_.假如_,
        '继续': 语法_.继续_,
        '结构': 语法_.结构_,
        '类型': 语法_.类型_,
        '另如': 语法_.另如_,
        '默认': 语法_.默认_,
        '若是': 语法_.若是_,
        '如果': 语法_.如果_,
        '属于': 语法_.属于_,
        '删除': 语法_.删除_,
        '跳出': 语法_.跳出_,
        '调试': 语法_.调试_,
        '位于': 语法_.位于_,
        '循环': 语法_.循环_,
        '选择': 语法_.选择_,
        '新建': 语法_.新建_,
        '善后': 语法_.善后_,
        '执行': 语法_.执行_,
        '真': 语法_.真_,
        '假': 语法_.假_,
        '真假': 语法_.真假_,
        '通用': 语法_.通用_,
        '列表': 语法_.列表_,
        '词典': 语法_.词典_,
        '未定': 语法_.未定_,
        '无值': 语法_.无值_,
        '文本': 语法_.文本_,
        '整数': 语法_.整数_,
        '整数8': 语法_.整数8_,
        '整数16': 语法_.整数16_,
        '整数32': 语法_.整数32_,
        '整数64': 语法_.整数64_,
        '正整数': 语法_.正整数_,
        '正整数8': 语法_.正整数8_,
        '正整数16': 语法_.正整数16_,
        '正整数32': 语法_.正整数32_,
        '正整数64': 语法_.正整数64_,
        '小数': 语法_.小数_,
        '小数32': 语法_.小数32_,
        '小数64': 语法_.小数64_,
        '复数64': 语法_.复数64_,
        '复数128': 语法_.复数128_,
        '指针': 语法_.指针_,
        '字符': 语法_.字符_,
        '字节': 语法_.字节_,
        '__win__': 语法_.__win__,
        '__linux__': 语法_.__linux__,
        '__darwin__': 语法_.__darwin__,
        '__386__': 语法_.__386__,
        '__amd64__': 语法_.__amd64__,
        '__arm__': 语法_.__arm__,
        '{': 语法_.左大括号_,
        '}': 语法_.右大括号_,
        '(': 语法_.左括号_,
        ')': 语法_.右括号_,
        '[': 语法_.左方括号_,        
        '?[': 语法_.问左方括号_,
        ']': 语法_.右方括号_,

        '.': 语法_.点号_,
        '...': 语法_.三点号_,

        ';': 语法_.分号_,
        ',': 语法_.逗号_,
        '<': 语法_.左尖号_,

        '<-': 语法_.左尖减号_,
        '>': 语法_.右尖号_,
        '->': 语法_.减右尖号_,

        '<=': 语法_.左尖等号_,
        '>=': 语法_.右尖等号_,
        '==': 语法_.双等号_,
        '!=': 语法_.叹号等号_,
        '=>': 语法_.等右尖号_,
        '=>:': 语法_.等右尖冒号_,
        '+': 语法_.加号_,
        '-': 语法_.减号_,
        '*': 语法_.星号_,
        '/': 语法_.斜杠号_,
        '%': 语法_.百分号_,
        '++': 语法_.双加号_,
        '--': 语法_.双减号_,
        '<<': 语法_.双左尖号_,
        '>>': 语法_.双右尖号_,
        '&': 语法_.且号_,
        '|': 语法_.或号_,
        '^': 语法_.异或号_,
        '!': 语法_.叹号_,
        '~': 语法_.波折号_,
        '&&': 语法_.双且号_,
        '||': 语法_.双或号_,
        '?': 语法_.问号_,
        '?.': 语法_.问点号_,
        ':': 语法_.冒号_,
        ':=': 语法_.冒等号_,
        ':>': 语法_.冒右尖号_,
        '=': 语法_.等号_,
        '+=': 语法_.加等号_,
        '-=': 语法_.减等号_,
        '*=': 语法_.星等号_,
        '/=': 语法_.斜杠等号_,
        '%=': 语法_.百分等号_,
        '<<=': 语法_.双左尖等号_,
        '>>=': 语法_.双右尖等号_,
        '&=': 语法_.且等号_,
        '|=': 语法_.或等号_,
        '^=': 语法_.异或等号_,
        '@': 语法_.艾特号_,
    });

    常量 标识符开始标记集 = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
    常量 标识符片段标记集 = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,];
    常量 关键字头 = 新建 集合_([33, 37, 38, 40, 41, 42, 43, 44, 45, 46, 47, 58, 59, 60, 61, 62, 63, 64, 91, 93, 94, 95, 123, 124, 125, 126, 20174, 20301, 20551, 20989, 21015, 21019, 21021, 21024, 21464, 21478, 21542, 21551, 21892, 22797, 22914, 23383, 23548, 23567, 23646, 24120, 24490, 25191, 25351, 25509, 25972, 25991, 26032, 26041, 26080, 26410, 26522, 27491, 30495, 31243, 31867, 32467, 32487, 33509, 33539, 35789, 35843, 36143, 36339, 36820, 36873, 36890, 40664])
    
    函数 看是否在Un词典(代码: 数字, 映射: 只读数组_<数字>): 真假 {
        如果 (代码 < 映射[0]) {
            返回 为假;
        }
        变量 低 = 0;
        变量 高: 数字 = 映射.长度;
        变量 中间: 数字;

        判断 (低 + 1 < 高) {
            中间 = 低 + (高 - 低) / 2;
            中间 -= 中间 % 2;
            如果 (映射[中间] <= 代码 && 代码 <= 映射[中间 + 1]) {
                返回 为真;
            }

            如果 (代码 < 映射[中间]) {
                高 = 中间;
            }
            否则 {
                低 = 中间 + 2;
            }
        }

        返回 为假;
    }

    /* @internal */ 
    导出 函数 是Un标识符开始(代码: 数字) {
        返回 看是否在Un词典(代码, 标识符开始标记集)
    }

    函数 是Un标识符片段(代码: 数字) {
        返回 看是否在Un词典(代码, 标识符片段标记集)
    }

    函数 制作翻转映射(源: 词典_<数字>): 文字[] {
        常量 结果: 文字[] = [];
        源.循环执行((值, 名称) => {
            结果[值] = 名称;
        });
        返回 结果;
    }

    常量 令牌文本组 = 制作翻转映射(文本令牌);

    导出 函数 令牌转为文字(t: 语法_): 文字 | 未定 {
        返回 令牌文本组[t];
    }

    /* @internal */
    导出 函数 文本转成令牌(s: 文字): 语法_ | 未定 {
        返回 文本令牌.获取(s);
    }

    /* @internal */
    导出 函数 计算行开始(文本: 文字): 数字[] {
        常量 结果: 数字[] = 新建 数组_();
        变量 首位 = 0;
        变量 行开始 = 0;
        判断 (首位 < 文本.长度) {
            常量 ch = 文本.字符代码在(首位);
            首位++;
            假如 (ch) {
                若是 字符_.回车符_:
                    如果 (文本.字符代码在(首位) === 字符_.换行符_) {
                        首位++;
                    }
                // 贯穿
                若是 字符_.换行符_:
                    结果.压入(行开始);
                    行开始 = 首位;
                    跳出;
                默认:
                    如果 (ch > 字符_.最大Ascii字符_ && 是换行符(ch)) {
                        结果.压入(行开始);
                        行开始 = 首位;
                    }
                    跳出;
            }
        }
        结果.压入(行开始);
        返回 结果;
    }

    导出 函数 获取行和字符的位置(源文件: 源文件_, 行: 数字, 字符: 数字): 数字 {
        返回 计算行和字符的位置(获取行开始(源文件), 行, 字符, 源文件.文本);
    }

    /* @internal */
    导出 函数 计算行和字符的位置(行开始: 只读数组_<数字>, 行: 数字, 字符: 数字, 调试文本?: 文字): 数字 {
        如果 (行 < 0 || 行 >= 行开始.长度) {
            调试_.失败(`Bad line number. Line: ${行}, lineStarts.length: ${行开始.长度} , line map 作为 correct? ${调试文本 !== 未定 ? arraysEqual(行开始, 计算行开始(调试文本)) : 'unknown'}`);
        }

        常量 位置 = 行开始[行] + 字符;
        如果 (行 < 行开始.长度 - 1) {
            调试_.断言(位置 < 行开始[行 + 1]);
        }
        否则 如果 (调试文本 !== 未定) {
            调试_.断言(位置 <= 调试文本.长度);
        }
        返回 位置;
    }

    /* @internal */
    导出 函数 获取行开始(源文件: 源文件族_): 只读数组_<数字> {
        返回 源文件.行词典 || (源文件.行词典 = 计算行开始(源文件.文本));
    }

    /* @internal */
    导出 函数 计算位置的行和字符(行开始: 只读数组_<数字>, 位置: 数字): 行和字符_ {
        变量 行数量 = 二分搜索(行开始, 位置, 身份, 比较值);
        如果 (行数量 < 0) {
            行数量 = ~行数量 - 1;
            调试_.断言(行数量 !== -1, 'position cannot precede the beginning of the 文件');
        }
        返回 {
            行: 行数量,
            字符: 位置 - 行开始[行数量]
        };
    }

    导出 函数 获取位置的行和字符(源文件: 源文件族_, position: 数字): 行和字符_ {
        返回 计算位置的行和字符(获取行开始(源文件), position);
    }

    导出 函数 是空白范围族(ch: 数字): 真假 {
        返回 是空白单行(ch) || 是换行符(ch);
    }

    导出 函数 是空白单行(ch: 数字): 真假 {
        返回 ch === 字符_.空格_ ||
            ch === 字符_.水平制表号_ ||
            ch === 字符_.垂直制表号_ ||
            ch === 字符_.分页号_ ||
            ch === 字符_.不间断空格_ ||
            ch === 字符_.下一行_ ||
            ch === 字符_.欧甘符_ ||
            ch >= 字符_.半角四空_ && ch <= 字符_.零宽度空格_ ||
            ch === 字符_.窄无换行空格_ ||
            ch === 字符_.数学模型空格_ ||
            ch === 字符_.表意空格_ ||
            ch === 字符_.字节顺序标记_;
    }

    导出 函数 是换行符(ch: 数字): 真假 {
        返回 ch === 字符_.换行符_ ||
            ch === 字符_.回车符_ ||
            ch === 字符_.行分隔符_ ||
            ch === 字符_.段落分隔符_;
    }

    函数 是数字(ch: 数字): 真假 {
        返回 ch >= 字符_._0 && ch <= 字符_._9;
    }

    /* @internal */
    导出 函数 是八进制(ch: 数字): 真假 {
        返回 ch >= 字符_._0 && ch <= 字符_._7;
    }

    导出 函数 可以开始杂项(文本: 文字, 首位: 数字): 真假 {
        常量 ch = 文本.字符代码在(首位);
        假如 (ch) {
            若是 字符_.回车符_:
            若是 字符_.换行符_:
            若是 字符_.水平制表号_:
            若是 字符_.垂直制表号_:
            若是 字符_.分页号_:
            若是 字符_.空格_:
            若是 字符_.斜杠号_:
            若是 字符_.左尖括号_:
            若是 字符_.或号_:
            若是 字符_.等号_:
            若是 字符_.右尖括号_:
                返回 为真;
            若是 字符_.井号_:
                返回 首位 === 0;
            默认:
                返回 ch > 字符_.最大Ascii字符_;
        }
    }

    /* @internal */
    导出 函数 跳过杂项(文本: 文字, 首位: 数字, 换行后停止?: 真假, 在注释处停止 = 为假): 数字 {
        如果 (位置是合成的(首位)) {
            返回 首位;
        }

        判断 (为真) {
            常量 ch = 文本.字符代码在(首位);
            假如 (ch) {
                若是 字符_.回车符_:
                    如果 (文本.字符代码在(首位 + 1) === 字符_.换行符_) {
                        首位++;
                    }
                // 贯穿
                若是 字符_.换行符_:
                    首位++;
                    如果 (换行后停止) {
                        返回 首位;
                    }
                    继续;
                若是 字符_.水平制表号_:
                若是 字符_.垂直制表号_:
                若是 字符_.分页号_:
                若是 字符_.空格_:
                    首位++;
                    继续;
                若是 字符_.斜杠号_:
                    如果 (在注释处停止) {
                        跳出;
                    }
                    如果 (文本.字符代码在(首位 + 1) === 字符_.斜杠号_) {
                        首位 += 2;
                        判断 (首位 < 文本.长度) {
                            如果 (是换行符(文本.字符代码在(首位))) {
                                跳出;
                            }
                            首位++;
                        }
                        继续;
                    }
                    如果 (文本.字符代码在(首位 + 1) === 字符_.星号_) {
                        首位 += 2;
                        判断 (首位 < 文本.长度) {
                            如果 (文本.字符代码在(首位) === 字符_.星号_ && 文本.字符代码在(首位 + 1) === 字符_.斜杠号_) {
                                首位 += 2;
                                跳出;
                            }
                            首位++;
                        }
                        继续;
                    }
                    跳出;

                若是 字符_.左尖括号_:
                若是 字符_.或号_:
                若是 字符_.等号_:
                若是 字符_.右尖括号_:
                    如果 (是冲突标记杂项(文本, 首位)) {
                        首位 = 扫描冲突标记杂项(文本, 首位);
                        继续;
                    }
                    跳出;

                若是 字符_.井号_:
                    如果 (首位 === 0 && 是指令杂项(文本, 首位)) {
                        首位 = 扫描指令杂项(文本, 首位);
                        继续;
                    }
                    跳出;

                默认:
                    如果 (ch > 字符_.最大Ascii字符_ && (是空白范围族(ch))) {
                        首位++;
                        继续;
                    }
                    跳出;
            }
            返回 首位;
        }
    }

    常量 合并冲突标记长度 = '<<<<<<<'.长度;

    函数 是冲突标记杂项(文本: 文字, 首位: 数字) {
        调试_.断言(首位 >= 0);
        如果 (首位 === 0 || 是换行符(文本.字符代码在(首位 - 1))) {
            常量 ch = 文本.字符代码在(首位);

            如果 ((首位 + 合并冲突标记长度) < 文本.长度) {
                循环 (变量 i = 0; i < 合并冲突标记长度; i++) {
                    如果 (文本.字符代码在(首位 + i) !== ch) {
                        返回 为假;
                    }
                }

                返回 ch === 字符_.等号_ ||
                    文本.字符代码在(首位 + 合并冲突标记长度) === 字符_.空格_;
            }
        }

        返回 为假;
    }

    函数 扫描冲突标记杂项(文本: 文字, 首位: 数字, 错误?: (诊断: 诊断信息_, 首位?: 数字, 长?: 数字) => 无值) {
        如果 (错误) {
            错误(诊断信息_.遇到冲突合并标记, 首位, 合并冲突标记长度);
        }

        常量 ch = 文本.字符代码在(首位);
        常量 len = 文本.长度;

        如果 (ch === 字符_.左尖括号_ || ch === 字符_.右尖括号_) {
            判断 (首位 < len && !是换行符(文本.字符代码在(首位))) {
                首位++;
            }
        }
        否则 {
            调试_.断言(ch === 字符_.或号_ || ch === 字符_.等号_);
            判断 (首位 < len) {
                常量 当前字符 = 文本.字符代码在(首位);
                如果 ((当前字符 === 字符_.等号_ || 当前字符 === 字符_.右尖括号_) && 当前字符 !== ch && 是冲突标记杂项(文本, 首位)) {
                    跳出;
                }

                首位++;
            }
        }

        返回 首位;
    }

    常量 指令杂项正则 = /^#!.*/;

    函数 是指令杂项(文本: 文字, 首位: 数字) {
        调试_.断言(首位 === 0);
        返回 指令杂项正则.测试(文本);
    }

    函数 扫描指令杂项(文本: 文字, 首位: 数字) {
        常量 指令 = 指令杂项正则.执行代码(文本)![0];
        首位 = 首位 + 指令.长度;
        返回 首位;
    }

    函数 迭代评论范围组<T, U>(减少: 真假, 文本: 文字, 首位: 数字, 尾随: 真假, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T, 记录: U | 未定) => U, 状态: T, 最初的?: U): U | 未定 {
        变量 待定首位!: 数字;
        变量 待定尾位!: 数字;
        变量 待定种类!: 注释种类_;
        变量 待定具有尾随新行!: 真假;
        变量 具有待定注释范围 = 为假;
        变量 收集 = 尾随 || 首位 === 0;
        变量 记录集 = 最初的;
        扫描: 判断 (首位 >= 0 && 首位 < 文本.长度) {
            常量 ch = 文本.字符代码在(首位);
            假如 (ch) {
                若是 字符_.回车符_:
                    如果 (文本.字符代码在(首位 + 1) === 字符_.换行符_) {
                        首位++;
                    }
                // falls through
                若是 字符_.换行符_:
                    首位++;
                    如果 (尾随) {
                        跳出 扫描;
                    }

                    收集 = 为真;
                    如果 (具有待定注释范围) {
                        待定具有尾随新行 = 为真;
                    }

                    继续;
                若是 字符_.水平制表号_:
                若是 字符_.垂直制表号_:
                若是 字符_.分页号_:
                若是 字符_.空格_:
                    首位++;
                    继续;
                若是 字符_.斜杠号_:
                    常量 下个字符 = 文本.字符代码在(首位 + 1);
                    变量 有尾随新行 = 为假;
                    如果 (下个字符 === 字符_.斜杠号_ || 下个字符 === 字符_.星号_) {
                        常量 种类 = 下个字符 === 字符_.斜杠号_ ? 语法_.单行注释杂项_ : 语法_.多行注释杂项_;
                        常量 开始首位 = 首位;
                        首位 += 2;
                        如果 (下个字符 === 字符_.斜杠号_) {
                            判断 (首位 < 文本.长度) {
                                如果 (是换行符(文本.字符代码在(首位))) {
                                    有尾随新行 = 为真;
                                    跳出;
                                }
                                首位++;
                            }
                        }
                        否则 {
                            判断 (首位 < 文本.长度) {
                                如果 (文本.字符代码在(首位) === 字符_.星号_ && 文本.字符代码在(首位 + 1) === 字符_.斜杠号_) {
                                    首位 += 2;
                                    跳出;
                                }
                                首位++;
                            }
                        }

                        如果 (收集) {
                            如果 (具有待定注释范围) {
                                记录集 = cb(待定首位, 待定尾位, 待定种类, 待定具有尾随新行, 状态, 记录集);
                                如果 (!减少 && 记录集) {
                                    返回 记录集;
                                }

                                具有待定注释范围 = 为假;
                            }

                            待定首位 = 开始首位;
                            待定尾位 = 首位;
                            待定种类 = 种类;
                            待定具有尾随新行 = 有尾随新行;
                            具有待定注释范围 = 为真;
                        }

                        继续;
                    }
                    跳出 扫描;
                默认:
                    如果 (ch > 字符_.最大Ascii字符_ && (是空白范围族(ch))) {
                        如果 (具有待定注释范围 && 是换行符(ch)) {
                            待定具有尾随新行 = 为真;
                        }
                        首位++;
                        继续;
                    }
                    跳出 扫描;
            }
        }

        如果 (具有待定注释范围) {
            记录集 = cb(待定首位, 待定尾位, 待定种类, 待定具有尾随新行, 状态, 记录集);
        }

        返回 记录集;
    }

    导出 函数 循环前导注释范围<U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假) => U): U | 未定;
    导出 函数 循环前导注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T) => U, 状态: T): U | 未定;
    导出 函数 循环前导注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T) => U, 状态?: T): U | 未定 {
        返回 迭代评论范围组(/*reduce*/ 为假, 文本, 首位, /*trailing*/ 为假, cb, 状态);
    }

    导出 函数 循环尾随注释范围<U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假) => U): U | 未定;
    导出 函数 循环尾随注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T) => U, 状态: T): U | 未定;
    导出 函数 循环尾随注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T) => U, 状态?: T): U | 未定 {
        返回 迭代评论范围组(/*reduce*/ 为假, 文本, 首位, /*trailing*/ 为真, cb, 状态);
    }

    导出 函数 缩小每个前导注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T, memo: U) => U, 状态: T, 最初的: U) {
        返回 迭代评论范围组(/*reduce*/ 为真, 文本, 首位, /*trailing*/ 为假, cb, 状态, 最初的);
    }

    导出 函数 缩小每个尾随注释范围<T, U>(文本: 文字, 首位: 数字, cb: (首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, 状态: T, memo: U) => U, 状态: T, 最初的: U) {
        返回 迭代评论范围组(/*reduce*/ 为真, 文本, 首位, /*trailing*/ 为真, cb, 状态, 最初的);
    }

    函数 附加注释范围(首位: 数字, 尾位: 数字, 种类: 注释种类_, 有尾随新行: 真假, _状态: 任意, 注释组: 注释范围_[]) {
        如果 (!注释组) {
            注释组 = [];
        }

        注释组.压入({ 种类, 首位, 尾位, 有尾随新行 });
        返回 注释组;
    }

    导出 函数 获取前导注释范围(文本: 文字, 首位: 数字): 注释范围_[] | 未定 {
        返回 缩小每个前导注释范围(文本, 首位, 附加注释范围, /*状态*/ 未定, /*initial*/ 未定);
    }

    导出 函数 获取跟踪注释范围(文本: 文字, 首位: 数字): 注释范围_[] | 未定 {
        返回 缩小每个尾随注释范围(文本, 首位, 附加注释范围, /*状态*/ 未定, /*initial*/ 未定);
    }

    导出 函数 获取指令(文本: 文字): 文字 | 未定 {
        常量 匹配 = 指令杂项正则.执行代码(文本);
        如果 (匹配) {
            返回 匹配[0];
        }
    }

    导出 函数 是标识符开始(ch: 数字): 真假 {
        返回 ch >= 字符_.A && ch <= 字符_.Z || ch >= 字符_.a && ch <= 字符_.z ||
            ch === 字符_.$ || ch === 字符_._ ||
            ch > 字符_.最大Ascii字符_ && 是Un标识符开始(ch);
    }

    导出 函数 是标识符片段(ch: 数字): 真假 {
        返回 ch >= 字符_.A && ch <= 字符_.Z || ch >= 字符_.a && ch <= 字符_.z ||
            ch >= 字符_._0 && ch <= 字符_._9 || ch === 字符_.$ || ch === 字符_._ ||
            ch > 字符_.最大Ascii字符_ && 是Un标识符片段(ch);
    }

    /* @internal */
    导出 函数 是标识符文本(名称: 文字): 真假 {
        如果 (!是标识符开始(名称.字符代码在(0))) {
            返回 为假;
        }

        循环 (变量 i = 1; i < 名称.长度; i++) {
            如果 (!是标识符片段(名称.字符代码在(i))) {
                返回 为假;
            }
        }

        返回 为真;
    }

    导出 函数 创建扫描器(跳过杂项: 真假, 文本内容?: 文字, 正在错误?: 错误回调_, 开始?: 数字, 长度?: 数字): 扫描器_ {
        变量 文本 = 文本内容!;
        变量 首位: 数字;

        变量 尾位: 数字;
        变量 开始首位: 数字;
        变量 令牌首位: 数字;

        变量 令牌: 语法_;
        变量 令牌值!: 文字;
        变量 令牌标志: 令牌标志_;

        设置文本(文本, 开始, 长度);

        返回 {
            获取开始首位: () => 开始首位,
            获取文本首位: () => 首位,
            获取令牌: () => 令牌,
            获取令牌首位: () => 令牌首位,
            获取令牌文本: () => 文本.子文字(令牌首位, 首位),
            获取令牌值: () => 令牌值,
            有扩展万码转义: () => (令牌标志 & 令牌标志_.扩展万码转义_) !== 0,
            具有前导换行符: () => (令牌标志 & 令牌标志_.前导换行_) !== 0,
            是标识符: () => 令牌 === 语法_.标识符_ || 令牌 > 语法_.尾保留_,
            是保留关键字: () => 令牌 >= 语法_.首保留_ && 令牌 <= 语法_.尾保留_,
            是未终止的: () => (令牌标志 & 令牌标志_.未终止的_) !== 0,
            获取令牌标志: () => 令牌标志,
            预扫描右尖号令牌,
            预扫描斜杠号令牌,
            预扫描模板令牌,
            扫描JSDoc令牌,
            扫描,
            获取文本,
            设置文本,
            设置正在错误,
            设置文本首位,
            尝试扫描,
            前瞻,
            扫描范围,
        };

        函数 错误(消息: 诊断信息_): 无值;
        函数 错误(消息: 诊断信息_, 错误首位: 数字, 长度: 数字): 无值;
        函数 错误(消息: 诊断信息_, 错误首位: 数字 = 首位, length?: 数字): 无值 {
            如果 (正在错误) {
                常量 旧首位 = 首位;
                首位 = 错误首位;
                正在错误(消息, length || 0);
                首位 = 旧首位;
            }
        }

        函数 扫描数字片段(): 文字 {
            变量 开始 = 首位;
            变量 允许分隔符 = 为假;
            变量 是上个令牌分隔符 = 为假;
            变量 结果 = '';
            判断 (为真) {
                常量 ch = 文本.字符代码在(首位);
                如果 (ch === 字符_._) {
                    令牌标志 |= 令牌标志_.包含分隔符_;
                    如果 (允许分隔符) {
                        允许分隔符 = 为假;
                        是上个令牌分隔符 = 为真;
                        结果 += 文本.子文字(开始, 首位);
                    }
                    否则 如果 (是上个令牌分隔符) {
                        错误(诊断信息_.不允许多个连续的数字分隔符, 首位, 1);
                    }
                    否则 {
                        错误(诊断信息_.此处不允许使用数字分隔符, 首位, 1);
                    }
                    首位++;
                    开始 = 首位;
                    继续;
                }
                如果 (是数字(ch)) {
                    允许分隔符 = 为真;
                    是上个令牌分隔符 = 为假;
                    首位++;
                    继续;
                }
                跳出;
            }
            如果 (文本.字符代码在(首位 - 1) === 字符_._) {
                错误(诊断信息_.此处不允许使用数字分隔符, 首位 - 1, 1);
            }
            返回 结果 + 文本.子文字(开始, 首位);
        }

        函数 扫描数字(): 文字 {
            常量 开始 = 首位;
            常量 主片段 = 扫描数字片段();
            变量 十进制片段!: 文字;
            变量 科学计数片段!: 文字;
            如果 (文本.字符代码在(首位) === 字符_.点号_) {
                首位++;
                十进制片段 = 扫描数字片段();
            }
            变量 尾位 = 首位;
            如果 (文本.字符代码在(首位) === 字符_.E || 文本.字符代码在(首位) === 字符_.e) {
                首位++;
                令牌标志 |= 令牌标志_.科学计数_;
                如果 (文本.字符代码在(首位) === 字符_.加号_ || 文本.字符代码在(首位) === 字符_.减号_) 首位++;
                常量 前面数字部分 = 首位;
                常量 最后片段 = 扫描数字片段();
                如果 (!最后片段) {
                    错误(诊断信息_.应为数字);
                }
                否则 {
                    科学计数片段 = 文本.子文字(尾位, 前面数字部分) + 最后片段;
                    尾位 = 首位;
                }
            }
            如果 (令牌标志 & 令牌标志_.包含分隔符_) {
                变量 结果 = 主片段;
                如果 (十进制片段) {
                    结果 += '.' + 十进制片段;
                }
                如果 (科学计数片段) {
                    结果 += 科学计数片段;
                }
                如果(文本.字符代码在(首位) === 字符_.i){ 
                    首位++;
                    令牌标志 |= 令牌标志_.虚部_;
                }
                返回 '' + +结果;
            }
            否则 {
                如果(文本.字符代码在(首位) === 字符_.i){ 
                    首位++;
                    令牌标志 |= 令牌标志_.虚部_;
                }
                返回 '' + +(文本.子文字(开始, 尾位)); // No need to use all the fragments; no _ removal needed
            }
        }

        函数 扫描八进制(): 数字 {
            常量 开始 = 首位;
            判断 (是八进制(文本.字符代码在(首位))) {
                首位++;
            }
            返回 +(文本.子文字(开始, 首位));
        }

        函数 扫描精确的十六进制(计数: 数字, 可以有分隔符: 真假): 数字 {
            返回 扫描十六进制(/*minCount*/ 计数, /*scanAsManyAsPossible*/ 为假, 可以有分隔符);
        }

        函数 扫描十六进制数字的最小数目(计数: 数字, 可以有分隔符: 真假): 数字 {
            返回 扫描十六进制(/*minCount*/ 计数, /*scanAsManyAsPossible*/ 为真, 可以有分隔符);
        }

        函数 扫描十六进制(最小计数: 数字, 尽可能多的扫描: 真假, 可以有分隔符: 真假): 数字 {
            变量 数字组 = 0;
            变量 值 = 0;
            变量 允许分隔符 = 为假;
            变量 是上个令牌分隔符 = 为假;
            判断 (数字组 < 最小计数 || 尽可能多的扫描) {
                常量 ch = 文本.字符代码在(首位);
                如果 (可以有分隔符 && ch === 字符_._) {
                    令牌标志 |= 令牌标志_.包含分隔符_;
                    如果 (允许分隔符) {
                        允许分隔符 = 为假;
                        是上个令牌分隔符 = 为真;
                    }
                    否则 如果 (是上个令牌分隔符) {
                        错误(诊断信息_.不允许多个连续的数字分隔符, 首位, 1);
                    }
                    否则 {
                        错误(诊断信息_.此处不允许使用数字分隔符, 首位, 1);
                    }
                    首位++;
                    继续;
                }
                允许分隔符 = 可以有分隔符;
                如果 (ch >= 字符_._0 && ch <= 字符_._9) {
                    值 = 值 * 16 + ch - 字符_._0;
                }
                否则 如果 (ch >= 字符_.A && ch <= 字符_.F) {
                    值 = 值 * 16 + ch - 字符_.A + 10;
                }
                否则 如果 (ch >= 字符_.a && ch <= 字符_.f) {
                    值 = 值 * 16 + ch - 字符_.a + 10;
                }
                否则 {
                    跳出;
                }
                首位++;
                数字组++;
                是上个令牌分隔符 = 为假;
            }
            如果 (数字组 < 最小计数) {
                值 = -1;
            }
            如果 (文本.字符代码在(首位 - 1) === 字符_._) {
                错误(诊断信息_.此处不允许使用数字分隔符, 首位 - 1, 1);
            }
            返回 值;
        }

        函数 扫描文本(): 文字 {
            常量 引号 = 文本.字符代码在(首位);
            首位++;
            变量 结果 = '';
            变量 开始 = 首位;
            判断 (为真) {
                如果 (首位 >= 尾位) {
                    结果 += 文本.子文字(开始, 首位);
                    令牌标志 |= 令牌标志_.未终止的_;
                    错误(诊断信息_.未终止文本字面量);
                    跳出;
                }
                常量 ch = 文本.字符代码在(首位);
                如果 (ch === 引号) {
                    结果 += 文本.子文字(开始, 首位);
                    首位++;
                    跳出;
                }
                如果 (ch === 字符_.反斜杠号_) {
                    结果 += 文本.子文字(开始, 首位);
                    结果 += 扫描转义序列();
                    开始 = 首位;
                    继续;
                }
                如果 (是换行符(ch)) {
                    结果 += 文本.子文字(开始, 首位);
                    令牌标志 |= 令牌标志_.未终止的_;
                    错误(诊断信息_.未终止文本字面量);
                    跳出;
                }
                首位++;
            }
            返回 结果;
        }

        函数 扫描模板和设置令牌值(): 语法_ {
            常量 开始包含反引号 = 文本.字符代码在(首位) === 字符_.反引号_;

            首位++;
            变量 开始 = 首位;
            变量 内容 = '';
            变量 生成的令牌: 语法_;

            判断 (为真) {
                如果 (首位 >= 尾位) {
                    内容 += 文本.子文字(开始, 首位);
                    令牌标志 |= 令牌标志_.未终止的_;
                    错误(诊断信息_.未完成模板字面量);
                    生成的令牌 = 开始包含反引号 ? 语法_.无替换模板字面量_ : 语法_.模板尾_;
                    跳出;
                }

                常量 当前字符 = 文本.字符代码在(首位);

                // '`'
                如果 (当前字符 === 字符_.反引号_) {
                    内容 += 文本.子文字(开始, 首位);
                    首位++;
                    生成的令牌 = 开始包含反引号 ? 语法_.无替换模板字面量_ : 语法_.模板尾_;
                    跳出;
                }

                // '${'
                如果 (当前字符 === 字符_.$ && 首位 + 1 < 尾位 && 文本.字符代码在(首位 + 1) === 字符_.左大括号_) {
                    内容 += 文本.子文字(开始, 首位);
                    首位 += 2;
                    生成的令牌 = 开始包含反引号 ? 语法_.模板头_ : 语法_.模板中_;
                    跳出;
                }

                如果 (当前字符 === 字符_.反斜杠号_) {
                    内容 += 文本.子文字(开始, 首位);
                    内容 += 扫描转义序列();
                    开始 = 首位;
                    继续;
                }

                如果 (当前字符 === 字符_.回车符_) {
                    内容 += 文本.子文字(开始, 首位);
                    首位++;

                    如果 (首位 < 尾位 && 文本.字符代码在(首位) === 字符_.换行符_) {
                        首位++;
                    }

                    内容 += '\n';
                    开始 = 首位;
                    继续;
                }

                首位++;
            }

            调试_.断言(生成的令牌 !== 未定);

            令牌值 = 内容;
            返回 生成的令牌;
        }

        函数 扫描转义序列(): 文字 {
            首位++;
            如果 (首位 >= 尾位) {
                错误(诊断信息_.文本的意外结尾);
                返回 '';
            }
            常量 ch = 文本.字符代码在(首位);
            首位++;
            假如 (ch) {
                若是 字符_._0:
                    返回 '\0';
                若是 字符_.b:
                    返回 '\b';
                若是 字符_.t:
                    返回 '\t';
                若是 字符_.n:
                    返回 '\n';
                若是 字符_.v:
                    返回 '\v';
                若是 字符_.f:
                    返回 '\f';
                若是 字符_.r:
                    返回 '\r';
                若是 字符_.单引号_:
                    返回 '\'';
                若是 字符_.双引号_:
                    返回 '\'';
                若是 字符_.u:
                    // '\u{DDDDDDDD}'
                    如果 (首位 < 尾位 && 文本.字符代码在(首位) === 字符_.左大括号_) {
                        令牌标志 |= 令牌标志_.扩展万码转义_;
                        首位++;
                        返回 扫描扩展万码转义();
                    }

                    // '\uDDDD'
                    返回 扫描十六进制转义(/*numDigits*/ 4);

                若是 字符_.x:
                    // '\xDD'
                    返回 扫描十六进制转义(/*numDigits*/ 2);
                若是 字符_.回车符_:
                    如果 (首位 < 尾位 && 文本.字符代码在(首位) === 字符_.换行符_) {
                        首位++;
                    }
                // falls through
                若是 字符_.换行符_:
                若是 字符_.行分隔符_:
                若是 字符_.段落分隔符_:
                    返回 '';
                默认:
                    返回 文字_.从字符代码(ch);
            }
        }

        函数 扫描十六进制转义(数目数字: 数字): 文字 {
            常量 转义值 = 扫描精确的十六进制(数目数字, /*canHaveSeparators*/ 为假);

            如果 (转义值 >= 0) {
                返回 文字_.从字符代码(转义值);
            }
            否则 {
                错误(诊断信息_.应为十六进制数字);
                返回 '';
            }
        }

        函数 扫描扩展万码转义(): 文字 {
            常量 转义值 = 扫描十六进制数字的最小数目(1, /*canHaveSeparators*/ 为假);
            变量 是无效的扩展转义 = 为假;

            如果 (转义值 < 0) {
                错误(诊断信息_.应为十六进制数字);
                是无效的扩展转义 = 为真;
            }
            否则 如果 (转义值 > 0x10FFFF) {
                错误(诊断信息_.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
                是无效的扩展转义 = 为真;
            }

            如果 (首位 >= 尾位) {
                错误(诊断信息_.文本的意外结尾);
                是无效的扩展转义 = 为真;
            }
            否则 如果 (文本.字符代码在(首位) === 字符_.右大括号_) {
                首位++;
            }
            否则 {
                错误(诊断信息_.未终止的_Unicode_转义序列);
                是无效的扩展转义 = 为真;
            }

            如果 (是无效的扩展转义) {
                返回 '';
            }

            返回 utf16编码转为文本(转义值);
        }

        函数 utf16编码转为文本(代码点: 数字): 文字 {
            调试_.断言(0x0 <= 代码点 && 代码点 <= 0x10FFFF);

            如果 (代码点 <= 65535) {
                返回 文字_.从字符代码(代码点);
            }

            常量 codeUnit1 = 数学_.floor((代码点 - 65536) / 1024) + 0xD800;
            常量 codeUnit2 = ((代码点 - 65536) % 1024) + 0xDC00;

            返回 文字_.从字符代码(codeUnit1, codeUnit2);
        }

        函数 看万码转义(): 数字 {
            如果 (首位 + 5 < 尾位 && 文本.字符代码在(首位 + 1) === 字符_.u) {
                常量 开始 = 首位;
                首位 += 2;
                常量 值 = 扫描精确的十六进制(4, /*canHaveSeparators*/ 为假);
                首位 = 开始;
                返回 值;
            }
            返回 -1;
        }

        函数 扫描标识符片段(): 文字 {
            变量 结果 = '';
            变量 开始 = 首位;
            判断 (首位 < 尾位) {
                变量 ch = 文本.字符代码在(首位);
                如果 (是标识符片段(ch)) {
                    首位++;
                }
                否则 如果 (ch === 字符_.反斜杠号_) {
                    ch = 看万码转义();
                    如果 (!(ch >= 0 && 是标识符片段(ch))) {
                        跳出;
                    }
                    结果 += 文本.子文字(开始, 首位);
                    结果 += 文字_.从字符代码(ch);
                    首位 += 6;
                    开始 = 首位;
                }
                否则 {
                    跳出;
                }
            }
            结果 += 文本.子文字(开始, 首位);
            返回 结果;
        }

        函数 获取标识符令牌(): 语法_ {
            常量 ch = 令牌值.字符代码在(0)
            如果 (令牌值.长度 <= 10 && 关键字头.具有(ch)) {
                变量 关键字 = 文本令牌.获取(令牌值);
                如果 (关键字 !== 未定) {
                    返回 令牌 = 关键字;
                }
            }
            如果 (ch === 字符_._) {
                令牌值.长度 === 1 ? 令牌标志 |= 令牌标志_.是空标识符_ : 令牌标志 |= 令牌标志_.是私有的_
            }
            返回 令牌 = 语法_.标识符_;
        }

        函数 扫描二或八进制(基: 数字): 数字 {
            调试_.断言(基 === 2 || 基 === 8, '数字只能小于 `2` 或 `8` .');

            变量 值 = 0;
            变量 数字的数量 = 0;
            变量 分隔符允许 = 为假;
            变量 是上个令牌分隔符 = 为假;
            判断 (为真) {
                常量 ch = 文本.字符代码在(首位);
                如果 (ch === 字符_._) {
                    令牌标志 |= 令牌标志_.包含分隔符_;
                    如果 (分隔符允许) {
                        分隔符允许 = 为假;
                        是上个令牌分隔符 = 为真;
                    }
                    否则 如果 (是上个令牌分隔符) {
                        错误(诊断信息_.不允许多个连续的数字分隔符, 首位, 1);
                    }
                    否则 {
                        错误(诊断信息_.此处不允许使用数字分隔符, 首位, 1);
                    }
                    首位++;
                    继续;
                }
                分隔符允许 = 为真;
                常量 ch的值 = ch - 字符_._0;
                如果 (!是数字(ch) || ch的值 >= 基) {
                    跳出;
                }
                值 = 值 * 基 + ch的值;
                首位++;
                数字的数量++;
                是上个令牌分隔符 = 为假;
            }
            如果 (数字的数量 === 0) {
                返回 -1;
            }
            如果 (文本.字符代码在(首位 - 1) === 字符_._) {
                错误(诊断信息_.此处不允许使用数字分隔符, 首位 - 1, 1);
                返回 值;
            }
            返回 值;
        }

        函数 扫描(): 语法_ {
            开始首位 = 首位;
            令牌标志 = 0;
            判断 (为真) {
                令牌首位 = 首位;
                如果 (首位 >= 尾位) {
                    返回 令牌 = 语法_.文件结尾令牌_;
                }
                变量 ch = 文本.字符代码在(首位);

                如果 (ch === 字符_.井号_ && 首位 === 0 && 是指令杂项(文本, 首位)) {
                    首位 = 扫描指令杂项(文本, 首位);
                    如果 (跳过杂项) {
                        继续;
                    }
                    否则 {
                        返回 令牌 = 语法_.指令杂项_;
                    }
                }

                假如 (ch) {
                    若是 字符_.换行符_:
                    若是 字符_.回车符_:
                        令牌标志 |= 令牌标志_.前导换行_;
                        如果 (跳过杂项) {
                            首位++;
                            继续;
                        }
                        否则 {
                            如果 (ch === 字符_.回车符_ && 首位 + 1 < 尾位 && 文本.字符代码在(首位 + 1) === 字符_.换行符_) {
                                首位 += 2;
                            }
                            否则 {
                                首位++;
                            }
                            返回 令牌 = 语法_.新行杂项_;
                        }
                    若是 字符_.水平制表号_:
                    若是 字符_.垂直制表号_:
                    若是 字符_.分页号_:
                    若是 字符_.空格_:
                        如果 (跳过杂项) {
                            首位++;
                            继续;
                        }
                        否则 {
                            判断 (首位 < 尾位 && 是空白单行(文本.字符代码在(首位))) {
                                首位++;
                            }
                            返回 令牌 = 语法_.空白杂项_;
                        }
                    若是 字符_.叹号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.叹号等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.叹号_;
                    若是 字符_.双引号_:
                        令牌值 = 扫描文本();
                        返回 令牌 = 语法_.文本字面量_;
                    若是 字符_.单引号_:
                        令牌值 = 扫描文本();
                        返回 令牌 = 语法_.字符字面量_;
                    若是 字符_.反引号_:
                        返回 令牌 = 扫描模板和设置令牌值();
                    若是 字符_.百分号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.百分等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.百分号_;
                    若是 字符_.且号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.且号_) {
                            返回 首位 += 2, 令牌 = 语法_.双且号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.且等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.且号_;
                    若是 字符_.左括号_:
                        首位++;
                        返回 令牌 = 语法_.左括号_;
                    若是 字符_.右括号_:
                        首位++;
                        返回 令牌 = 语法_.右括号_;
                    若是 字符_.星号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.星等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.星号_;
                    若是 字符_.加号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.加号_) {
                            返回 首位 += 2, 令牌 = 语法_.双加号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.加等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.加号_;
                    若是 字符_.逗号_:
                        首位++;
                        返回 令牌 = 语法_.逗号_;
                    若是 字符_.减号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.减号_) {
                            返回 首位 += 2, 令牌 = 语法_.双减号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.减等号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.右尖括号_) {
                            返回 首位 += 2, 令牌 = 语法_.减右尖号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.减号_;
                    若是 字符_.点号_:
                        如果 (是数字(文本.字符代码在(首位 + 1))) {
                            令牌值 = 扫描数字();
                            返回 令牌 = 语法_.数字字面量_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.点号_ && 文本.字符代码在(首位 + 2) === 字符_.点号_) {
                            返回 首位 += 3, 令牌 = 语法_.三点号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.点号_;
                    若是 字符_.斜杠号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.斜杠号_) {
                            首位 += 2;

                            判断 (首位 < 尾位) {
                                如果 (是换行符(文本.字符代码在(首位))) {
                                    跳出;
                                }
                                首位++;

                            }

                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                返回 令牌 = 语法_.单行注释杂项_;
                            }
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.星号_) {
                            首位 += 2;
                            如果 (文本.字符代码在(首位) === 字符_.星号_ && 文本.字符代码在(首位 + 1) !== 字符_.斜杠号_) {
                                令牌标志 |= 令牌标志_.前导JSDoc注释_;
                            }

                            变量 注释已关闭 = 为假;
                            判断 (首位 < 尾位) {
                                常量 ch = 文本.字符代码在(首位);

                                如果 (ch === 字符_.星号_ && 文本.字符代码在(首位 + 1) === 字符_.斜杠号_) {
                                    首位 += 2;
                                    注释已关闭 = 为真;
                                    跳出;
                                }

                                如果 (是换行符(ch)) {
                                    令牌标志 |= 令牌标志_.前导换行_;
                                }
                                首位++;
                            }

                            如果 (!注释已关闭) {
                                错误(诊断信息_.应为_Asterisk_Slash);
                            }

                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                如果 (!注释已关闭) {
                                    令牌标志 |= 令牌标志_.未终止的_;
                                }
                                返回 令牌 = 语法_.多行注释杂项_;
                            }
                        }

                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.斜杠等号_;
                        }

                        首位++;
                        返回 令牌 = 语法_.斜杠号_;

                    若是 字符_._0:
                        如果 (首位 + 2 < 尾位 && (文本.字符代码在(首位 + 1) === 字符_.X || 文本.字符代码在(首位 + 1) === 字符_.x)) {
                            首位 += 2;
                            // 0x 或 0X
                            变量 值 = 扫描十六进制数字的最小数目(1, /*canHaveSeparators*/ 为真);
                            如果 (值 < 0) {
                                错误(诊断信息_.应为十六进制数字);
                                值 = 0;
                            }
                            令牌值 = '' + 值;
                            令牌标志 |= 令牌标志_.十六进制说明符_;
                            返回 令牌 = 语法_.数字字面量_;
                        }
                        否则 如果 (首位 + 2 < 尾位 && (文本.字符代码在(首位 + 1) === 字符_.B || 文本.字符代码在(首位 + 1) === 字符_.b)) {
                            首位 += 2;
                            // 0B 或 0b
                            变量 值 = 扫描二或八进制(/* base */ 2);
                            如果 (值 < 0) {
                                错误(诊断信息_.应为二进制数字);
                                值 = 0;
                            }
                            令牌值 = '' + 值;
                            令牌标志 |= 令牌标志_.二进制说明符_;
                            返回 令牌 = 语法_.数字字面量_;
                        }
                        否则 如果 (首位 + 2 < 尾位 && (文本.字符代码在(首位 + 1) === 字符_.O || 文本.字符代码在(首位 + 1) === 字符_.o)) {
                            首位 += 2;
                            // 0o 或 0O
                            变量 值 = 扫描二或八进制(/* base */ 8);
                            如果 (值 < 0) {
                                错误(诊断信息_.应为八进制数字);
                                值 = 0;
                            }
                            令牌值 = '' + 值;
                            令牌标志 |= 令牌标志_.八进制说明符_;
                            返回 令牌 = 语法_.数字字面量_;
                        }
                        如果 (首位 + 1 < 尾位 && 是八进制(文本.字符代码在(首位 + 1))) {
                            令牌值 = '' + 扫描八进制();
                            令牌标志 |= 令牌标志_.八进制_;
                            返回 令牌 = 语法_.数字字面量_;
                        }
                    若是 字符_._1:
                    若是 字符_._2:
                    若是 字符_._3:
                    若是 字符_._4:
                    若是 字符_._5:
                    若是 字符_._6:
                    若是 字符_._7:
                    若是 字符_._8:
                    若是 字符_._9:
                        令牌值 = 扫描数字();
                        返回 令牌 = 语法_.数字字面量_;
                    若是 字符_.冒号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.右尖括号_) {
                            返回 首位 += 2, 令牌 = 语法_.冒右尖号_;
                        }

                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.冒等号_;
                        }

                        首位++;
                        返回 令牌 = 语法_.冒号_;
                    若是 字符_.分号_:
                        首位++;
                        返回 令牌 = 语法_.分号_;
                    若是 字符_.左尖括号_:
                        如果 (是冲突标记杂项(文本, 首位)) {
                            首位 = 扫描冲突标记杂项(文本, 首位, 错误);
                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                返回 令牌 = 语法_.冲突标记杂项_;
                            }
                        }

                        如果 (文本.字符代码在(首位 + 1) === 字符_.减号_) {
                            返回 首位 += 2, 令牌 = 语法_.左尖减号_;
                        }

                        如果 (文本.字符代码在(首位 + 1) === 字符_.左尖括号_) {
                            如果 (文本.字符代码在(首位 + 2) === 字符_.等号_) {
                                返回 首位 += 3, 令牌 = 语法_.双左尖等号_;
                            }
                            返回 首位 += 2, 令牌 = 语法_.双左尖号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.左尖等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.左尖号_;
                    若是 字符_.等号_:
                        如果 (是冲突标记杂项(文本, 首位)) {
                            首位 = 扫描冲突标记杂项(文本, 首位, 错误);
                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                返回 令牌 = 语法_.冲突标记杂项_;
                            }
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.双等号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.右尖括号_ && 文本.字符代码在(首位 + 2) === 字符_.冒号_) {
                            返回 首位 += 3, 令牌 = 语法_.等右尖冒号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.右尖括号_) {
                            返回 首位 += 2, 令牌 = 语法_.等右尖号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.等号_;
                    若是 字符_.右尖括号_:
                        如果 (是冲突标记杂项(文本, 首位)) {
                            首位 = 扫描冲突标记杂项(文本, 首位, 错误);
                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                返回 令牌 = 语法_.冲突标记杂项_;
                            }
                        }
                        首位++;
                        返回 令牌 = 语法_.右尖号_;
                    若是 字符_.问号_:
                        如果(文本.字符代码在(首位 + 1) === 字符_.点号_){
                            返回 首位 += 2, 令牌 = 语法_.问点号_
                        }
                        如果(文本.字符代码在(首位 + 1) === 字符_.左方括号_){
                            返回 首位 += 2, 令牌 = 语法_.问左方括号_
                        }
                        首位++;
                        返回 令牌 = 语法_.问号_;
                    若是 字符_.左方括号_:
                        首位++;
                        返回 令牌 = 语法_.左方括号_;
                    若是 字符_.右方括号_:
                        首位++;
                        返回 令牌 = 语法_.右方括号_;
                    若是 字符_.异或号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.异或等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.异或号_;
                    若是 字符_.左大括号_:
                        首位++;
                        返回 令牌 = 语法_.左大括号_;
                    若是 字符_.或号_:
                        如果 (是冲突标记杂项(文本, 首位)) {
                            首位 = 扫描冲突标记杂项(文本, 首位, 错误);
                            如果 (跳过杂项) {
                                继续;
                            }
                            否则 {
                                返回 令牌 = 语法_.冲突标记杂项_;
                            }
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.或号_) {
                            返回 首位 += 2, 令牌 = 语法_.双或号_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                            返回 首位 += 2, 令牌 = 语法_.或等号_;
                        }
                        首位++;
                        返回 令牌 = 语法_.或号_;
                    若是 字符_.右大括号_:
                        首位++;
                        返回 令牌 = 语法_.右大括号_;
                    若是 字符_.波折号_:
                        首位++;
                        返回 令牌 = 语法_.波折号_;
                    若是 字符_.艾特号_:
                        首位++;
                        返回 令牌 = 语法_.艾特号_;
                    若是 字符_.井号_:
                        如果 (文本.字符代码在(首位 + 1) === 字符_.定_ && 文本.字符代码在(首位 + 2) === 字符_.义_) {
                            令牌标志 |= 令牌标志_.预处理开始_;
                            返回 首位 += 3, 令牌 = 语法_.预_定义_;
                        }
                        如果 (文本.字符代码在(首位 + 1) === 字符_.结_ && 文本.字符代码在(首位 + 2) === 字符_.束_) {
                            令牌标志 |= 令牌标志_.预处理结束_;
                            返回 首位 += 3, 令牌 = 语法_.预_完成定义_;
                        }
                    若是 字符_.反斜杠号_:
                        常量 转义字符 = 看万码转义();
                        如果 (转义字符 >= 0 && 是标识符开始(转义字符)) {
                            首位 += 6;
                            令牌值 = 文字_.从字符代码(转义字符) + 扫描标识符片段();
                            返回 令牌 = 获取标识符令牌();
                        }
                        错误(诊断信息_.无效字符);
                        首位++;
                        返回 令牌 = 语法_.未知_;
                    默认:
                        如果 (是标识符开始(ch)) {
                            首位++;
                            判断 (首位 < 尾位 && 是标识符片段(ch = 文本.字符代码在(首位))) 首位++;
                            令牌值 = 文本.子文字(令牌首位, 首位);
                            如果 (ch === 字符_.反斜杠号_) {
                                令牌值 += 扫描标识符片段();
                            }
                            返回 令牌 = 获取标识符令牌();
                        }
                        否则 如果 (是空白单行(ch)) {
                            首位++;
                            继续;
                        }
                        否则 如果 (是换行符(ch)) {
                            令牌标志 |= 令牌标志_.前导换行_;
                            首位++;
                            继续;
                        }
                        错误(诊断信息_.无效字符);
                        首位++;
                        返回 令牌 = 语法_.未知_;
                }
            }
        }

        函数 预扫描右尖号令牌(): 语法_ {
            如果 (令牌 === 语法_.右尖号_) {
                如果 (文本.字符代码在(首位) === 字符_.右尖括号_) {
                    如果 (文本.字符代码在(首位 + 1) === 字符_.等号_) {
                        返回 首位 += 2, 令牌 = 语法_.双右尖等号_;
                    }
                    首位++;
                    返回 令牌 = 语法_.双右尖号_;
                }
                如果 (文本.字符代码在(首位) === 字符_.等号_) {
                    首位++;
                    返回 令牌 = 语法_.右尖等号_;
                }
            }
            返回 令牌;
        }

        函数 预扫描斜杠号令牌(): 语法_ {
            如果 (令牌 === 语法_.斜杠号_ || 令牌 === 语法_.斜杠等号_) {
                变量 p = 令牌首位 + 1;
                变量 在转义 = 为假;
                变量 在字符类中 = 为假;
                判断 (为真) {
                    如果 (p >= 尾位) {
                        令牌标志 |= 令牌标志_.未终止的_;
                        错误(诊断信息_.未结束的正则表达式字面量);
                        跳出;
                    }

                    常量 ch = 文本.字符代码在(p);
                    如果 (是换行符(ch)) {
                        令牌标志 |= 令牌标志_.未终止的_;
                        错误(诊断信息_.未结束的正则表达式字面量);
                        跳出;
                    }

                    如果 (在转义) {
                        在转义 = 为假;
                    }
                    否则 如果 (ch === 字符_.斜杠号_ && !在字符类中) {
                        p++;
                        跳出;
                    }
                    否则 如果 (ch === 字符_.左方括号_) {
                        在字符类中 = 为真;
                    }
                    否则 如果 (ch === 字符_.反斜杠号_) {
                        在转义 = 为真;
                    }
                    否则 如果 (ch === 字符_.右方括号_) {
                        在字符类中 = 为假;
                    }
                    p++;
                }

                判断 (p < 尾位 && 是标识符片段(文本.字符代码在(p))) {
                    p++;
                }
                首位 = p;
                令牌值 = 文本.子文字(令牌首位, 首位);
                令牌 = 语法_.正则表达式字面量_;
            }
            返回 令牌;
        }

        函数 预扫描模板令牌(): 语法_ {
            调试_.断言(令牌 === 语法_.右大括号_, '"预扫描模板令牌" 应仅在 "}" 时调用');
            首位 = 令牌首位;
            返回 令牌 = 扫描模板和设置令牌值();
        }

        函数 扫描JSDoc令牌(): JsDoc语法_ {
            如果 (首位 >= 尾位) {
                返回 令牌 = 语法_.文件结尾令牌_;
            }

            开始首位 = 首位;
            令牌首位 = 首位;

            常量 ch = 文本.字符代码在(首位);
            首位++;
            假如 (ch) {
                若是 字符_.水平制表号_:
                若是 字符_.垂直制表号_:
                若是 字符_.分页号_:
                若是 字符_.空格_:
                    判断 (首位 < 尾位 && 是空白单行(文本.字符代码在(首位))) {
                        首位++;
                    }
                    返回 令牌 = 语法_.空白杂项_;
                若是 字符_.艾特号_:
                    返回 令牌 = 语法_.艾特号_;
                若是 字符_.换行符_:
                若是 字符_.回车符_:
                    返回 令牌 = 语法_.新行杂项_;
                若是 字符_.星号_:
                    返回 令牌 = 语法_.星号_;
                若是 字符_.左大括号_:
                    返回 令牌 = 语法_.左大括号_;
                若是 字符_.右大括号_:
                    返回 令牌 = 语法_.右大括号_;
                若是 字符_.左方括号_:
                    返回 令牌 = 语法_.左方括号_;
                若是 字符_.右方括号_:
                    返回 令牌 = 语法_.右方括号_;
                若是 字符_.左尖括号_:
                    返回 令牌 = 语法_.左尖号_;
                若是 字符_.等号_:
                    返回 令牌 = 语法_.等号_;
                若是 字符_.逗号_:
                    返回 令牌 = 语法_.逗号_;
                若是 字符_.点号_:
                    返回 令牌 = 语法_.点号_;
            }

            如果 (是标识符开始(ch)) {
                判断 (是标识符片段(文本.字符代码在(首位)) && 首位 < 尾位) {
                    首位++;
                }
                令牌值 = 文本.子文字(令牌首位, 首位);
                返回 令牌 = 语法_.标识符_;
            }
            否则 {
                返回 令牌 = 语法_.未知_;
            }
        }

        函数 推测助手<T>(cb: () => T, 是向前看: 真假): T {
            常量 储存首位 = 首位;
            常量 储存开始首位 = 开始首位;
            常量 储存令牌首位 = 令牌首位;
            常量 储存令牌 = 令牌;
            常量 储存令牌值 = 令牌值;
            常量 储存令牌标志 = 令牌标志;
            常量 结果 = cb();

            如果 (!结果 || 是向前看) {
                首位 = 储存首位;
                开始首位 = 储存开始首位;
                令牌首位 = 储存令牌首位;
                令牌 = 储存令牌;
                令牌值 = 储存令牌值;
                令牌标志 = 储存令牌标志;
            }
            返回 结果;
        }

        函数 扫描范围<T>(开始: 数字, 长度: 数字, cb: () => T): T {
            常量 储存尾位 = 尾位;
            常量 储存首位 = 首位;
            常量 储存开始首位 = 开始首位;
            常量 储存令牌首位 = 令牌首位;
            常量 储存令牌 = 令牌;
            常量 储存令牌值 = 令牌值;
            常量 储存令牌标志 = 令牌标志;

            设置文本(文本, 开始, 长度);
            常量 结果 = cb();

            尾位 = 储存尾位;
            首位 = 储存首位;
            开始首位 = 储存开始首位;
            令牌首位 = 储存令牌首位;
            令牌 = 储存令牌;
            令牌值 = 储存令牌值;
            令牌标志 = 储存令牌标志;

            返回 结果;
        }

        函数 前瞻<T>(cb: () => T): T {
            返回 推测助手(cb, /*isLookahead*/ 为真);
        }

        函数 尝试扫描<T>(cb: () => T): T {
            返回 推测助手(cb, /*isLookahead*/ 为假);
        }

        函数 获取文本(): 文字 {
            返回 文本;
        }

        函数 设置文本(新文本: 文字 | 未定, 开始: 数字 | 未定, 长度: 数字 | 未定) {
            文本 = 新文本 || '';
            尾位 = 长度 === 未定 ? 文本.长度 : 开始! + 长度;
            设置文本首位(开始 || 0);
        }

        函数 设置正在错误(错误回调: 错误回调_) {
            正在错误 = 错误回调;
        }

        函数 设置文本首位(文本首位: 数字) {
            调试_.断言(文本首位 >= 0);
            首位 = 文本首位;
            开始首位 = 文本首位;
            令牌首位 = 文本首位;
            令牌 = 语法_.未知_;
            令牌值 = 未定!;
            令牌标志 = 0;
        }
    }
}
